﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Text.RegularExpressions;
using System.Web.Script;
using System.Data;

/// <summary>
/// Summary description for FrmRequirement
/// </summary>
public partial class Boundary_FrmRequirement : System.Web.UI.Page
{
    System.IFormatProvider format = new System.Globalization.CultureInfo("es-ES", true);

    private string profile = "";
    private string role = "";
    private String position = "";

    private DataTable conflictosData;
    private DataTable requerimientosData;

    TreeNode temp = new TreeNode();
    HttpCookie cookie;
    
    private CtrlRequerimientos ctrlFunctionalRequirement
    {
        get
        {
            return (CtrlRequerimientos)(Session["ctrlFunctionalRequirement"]);
        }
        set
        {
            (Session["ctrlFunctionalRequirement"]) = value;
        }
    }


    private CtrlHumanResource ctrlHumanResource
    {
        get
        {
            return (CtrlHumanResource)(Session["ctrlHumanResource"]);
        }
        set
        {
            (Session["ctrlHumanResource"]) = value;
        }
    }

    private CtrlProject ctrlProject
    {
        get
        {
            return (CtrlProject)(Session["ctrlProject"]);
        }
        set
        {
            (Session["ctrlProject"]) = value;
        }
    }

    private string changing
    {
        get
        {
            return (string)(ViewState["changing"]);
        }
        set
        {
            ViewState["changing"] = value;
        }
    }

    private int iIdFather
    {
        get
        {
            return (int)(ViewState["iIdFather"]);
        }
        set
        {
            ViewState["iIdFather"] = value;
        }
    }

    private bool bReusable
    {
        get
        {
            return (bool)(ViewState["bReusable"]);
        }
        set
        {
            ViewState["bReusable"] = value;
        }
    }

    /// Metodo que se ejecuta cuando se carga la pagina
    protected void Page_Load(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = true;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;

        // Redirection if there is no cookie.
        HttpCookie cookie = Request.Cookies.Get("requmanaLogin");
        if (cookie == null)
        {
            Response.Redirect("FrmLogin.aspx");
        }
        else
        {
            profile = cookie.Values[3];
            role = cookie.Values[4];
        }
        if (Session["ctrlHumanResource"] == null)
        {
            ctrlHumanResource = new CtrlHumanResource();
        }

        if (Session["ctrlFunctionalRequirement"] == null)
        {
            ctrlFunctionalRequirement = new CtrlRequerimientos();
        }

        if (Session["ctrlProject"] == null)
        {
            ctrlProject = new CtrlProject();
        }
        if (! IsPostBack){

            disableFields();
            DataTable dtTemp;
            ctlComboBoxFuente.setDataSource(ctrlHumanResource.getData(), "Name", "Id");
            ctlComboBoxFuenteRNF.setDataSource(ctrlHumanResource.getData(), "Name", "Id");
            ctlComboBoxVersion.setDataSource(ctrlHumanResource.getData(), "Name", "Id");        

            dtTemp = new DataTable();

            dtTemp.Columns.Add("Id", Type.GetType("System.String"));
            dtTemp.Columns.Add("Name", Type.GetType("System.String"));

            ctlComboBoxEstado.setDataSource(ctrlFunctionalRequirement.obtenerEstados(), "Estado", "Id");
            dtTemp = new DataTable();

            dtTemp.Columns.Add("Id", Type.GetType("System.String"));
            dtTemp.Columns.Add("Estado", Type.GetType("System.String"));

            ctlComboBoxPrioridad.setDataSource(ctrlFunctionalRequirement.obtenerPrioridades(), "Prioridad", "Id");
            dtTemp = new DataTable();

            dtTemp.Columns.Add("Id", Type.GetType("System.String"));
            dtTemp.Columns.Add("Prioridad", Type.GetType("System.String"));

       
            disableFields();
            checkNuevaVersionRF.Checked = false;
            tree.Nodes.Clear();

            TreeNode raiz = new TreeNode();
            raiz.Text = "Lista de Proyectos";
            raiz.Collapse();
            raiz.SelectAction = TreeNodeSelectAction.Select;

            tree.Nodes.Add(raiz);
            cargarProyectos(raiz);            
        }

        btnAgregarMod.Enabled = false;

        //tree.NodeIndent = 50;

        if (!(IsPostBack))
        {
            iIdFather = 0;
            bReusable = false;
        }

    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Carga los grids de conflictos.
    private void cargaConflictos()
    {
        requerimientosData = ctrlFunctionalRequirement.sinConflictos(Convert.ToInt32(tree.SelectedNode.Value));
        gridRequerimientos.DataSource = requerimientosData;
        gridRequerimientos.DataBind();

        conflictosData = ctrlFunctionalRequirement.conConflictos(Convert.ToInt32(tree.SelectedNode.Value));
        gridConflictos.DataSource = conflictosData;
        gridConflictos.DataBind();
    }

    
    protected void btnLeft(object sender, EventArgs e) {
        try
        {
            if (gridConflictos.SelectedIndex != -1)
            {
                conflictosData.Rows[gridConflictos.SelectedIndex].Delete();
                gridConflictos.DataSource = conflictosData;
                gridConflictos.DataBind();
            }
        }
        catch
        { }
    }

    protected void btnRight(object sender, EventArgs e)
    {
        try
        {
            if (gridRequerimientos.SelectedIndex != -1)
            {
                requerimientosData.Rows[gridRequerimientos.SelectedIndex].Delete();
                gridRequerimientos.DataSource = requerimientosData;
                gridRequerimientos.DataBind();
            }
        }
        catch { }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    // Valida los campos en los que se escribe
    public bool validateFields()
    {
        bool valid = true;
        //bool validDate = true;

        hideValidations();

        Regex regularNotNull = new Regex("^(.{1,50})$");
        Regex regularNull = new Regex("^(.{0,50})$");
        Regex identifier = new Regex("^(\\d{1,5})$");
        Regex effort = new Regex("^((\\d+(\\[.,]\\d+)?)?)$");

        DateTime temp = new DateTime();

        System.IFormatProvider format = new System.Globalization.CultureInfo("es-ES", true);

        if (updatePanelRF.Visible == true)
        {
            
            if (txtNombre.Text == "")
            {
                nombreValidation.Visible = true;
                nombreValComment.Visible = true;
                valid = false;
            }
            else
            {
                if (!(regularNotNull.IsMatch(txtNombre.Text)))
                {
                    nombreValidation.Visible = true;
                    nombreValFormat.Visible = true;
                    valid = false;
                }
            }

            if (txtIteracion.Text == "")
            {
                iteracionValidation.Visible = true;
                iteracionValComment.Visible = true;
                valid = false;
            }
            else
            {
                if (!(identifier.IsMatch(txtIteracion.Text)))
                {
                    iteracionValidation.Visible = true;
                    iteracionValFormat.Visible = true;
                    valid = false;
                }
            }

            if (txtDescripcion.Text == "")
            {
                descripcionValidation.Visible = true;
                descripcionValComment.Visible = true;
                valid = false;
            }

            if (txtJustificacion.Text == "")
            {
                justificacionValidation.Visible = true;
                justificacionValComment.Visible = true;
                valid = false;
            }

            if (txtBegin.Text != "")
            {
                if (!(DateTime.TryParse(txtBegin.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                {
                    beginValidation.Visible = true;
                    beginValFormat.Visible = true;
                    valid = false;
                }
            }
            else
            {
                beginValidation.Visible = true;
                beginValComment.Visible = true;
                valid = false;
            }

            if (txtEnd.Text != "")
            {
                if (!(DateTime.TryParse(txtEnd.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                {
                    endValidation.Visible = true;
                    endValFormat.Visible = true;
                    valid = false;
                }

                if (txtBegin.Text != "")
                {
                    if (!(DateTime.TryParse(txtBegin.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                    {
                        beginValidation.Visible = true;
                        beginValFormat.Visible = true;
                        valid = false;
                    }

                    if ((DateTime.TryParse(txtBegin.Text, format, System.Globalization.DateTimeStyles.None, out temp)) &&
                        (DateTime.TryParse(txtEnd.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                    {

                        DateTime begin = new DateTime();
                        DateTime end = new DateTime();

                        begin = DateTime.Parse(txtBegin.Text, format);
                        end = DateTime.Parse(txtEnd.Text, format);

                        int difference = DateTime.Compare(end, begin);
                        if (difference <= 0)
                        {
                            endValidation.Visible = true;
                            endValComment.Visible = true;
                            valid = false;
                        }
                    }
                }
            }

            if(!(effort.IsMatch(txtEsfuerzo.Text)))
            {
                esfuerzoValidation.Visible = true;
                esfuerzoValFormat.Visible = true;
                valid = false;
            }

            /*if (txtEsfuerzo.Text != "")
            {
                if (!(effort.IsMatch(txtEsfuerzo.Text)))
                {
                    esfuerzoValidation.Visible = true;
                    esfuerzoValFormat.Visible = true;
                    valid = false;
                }
            }

            if (txtCriterioDeAceptacion.Text == "")
            {
                criterioValidation.Visible = true;
                criterioValComment.Visible = true;
                valid = false;
            }*/

            if (checkNuevaVersionRF.Checked == true)
            {
                if (txtFechaVersion.Text != "")
                {
                    if (!(DateTime.TryParse(txtFechaVersion.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                    {
                        fechaVersionValidation.Visible = true;
                        fechaVersionValFormat.Visible = true;
                        valid = false;
                    }
                }
                else
                {
                    fechaVersionValidation.Visible = true;
                    fechaVersionValComment.Visible = true;
                    valid = false;
                }

                if (txtDescripcionVersion.Text == "")
                {
                    descripcionVersionValidation.Visible = true;
                    descripcionVersionValComment.Visible = true;
                    valid = false;
                }
            }
        }
        else
        {
            if(txtNombreRNF.Text == "")
            {
                nombreRNFValidation.Visible = true;
                nombreRNFValComment.Visible = true;
                valid = false;
            }
            else
            {
                if (!(regularNotNull.IsMatch(txtNombreRNF.Text)))
                {
                    nombreRNFValidation.Visible = true;
                    nombreRNFValFormat.Visible = true;
                    valid = false;
                }
            }
            if (txtDescripcionRNF.Text == "")
            {
                descripcionRNFValidation.Visible = true;
                descripcionRNFValComment.Visible = true;
                valid = false;
            }

            if (checkNuevaVersionRNF.Checked == true)
            {
                if (txtFechaRNF.Text != "")
                {
                    if (!(DateTime.TryParse(txtFechaRNF.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                    {
                        fechaRNFValidation.Visible = true;
                        fechaRNFValFormat.Visible = true;
                        valid = false;
                    }
                }
                else
                {
                    fechaRNFValidation.Visible = true;
                    fechaRNFValComment.Visible = true;
                    valid = false;
                }

                if (txtDescripcionCambioRNF.Text == "")
                {
                    descripcionCambioValidation.Visible = true;
                    descripcionCambioValComment.Visible = true;
                    valid = false;
                }
            }
        }
        
        return valid;
    }

    // carga los proyectos del arbol
    private void cargarProyectos(TreeNode nodo)
    {
        cookie = Request.Cookies.Get("requmanaLogin");
        nodo.ChildNodes.Clear();
        bool admin = (profile == "0");
        DataSet temp = new DataSet();
        string bla = cookie.Values[5];

        if (admin)
        {
            temp = ctrlProject.getData();
        }
        else
        {
            temp = ctrlProject.getDataC(Int32.Parse(cookie.Values[5]));
        }

        foreach (DataRow row in temp.Tables[0].Rows)
        {
            TreeNode newNode = new TreeNode(row["Name"].ToString(), row["Id"].ToString());
            newNode.PopulateOnDemand = true;
            newNode.Collapse();
            newNode.SelectAction = TreeNodeSelectAction.Select;
            nodo.ChildNodes.Add(newNode);
        }

    }

    // carga los modulos del arbol
    private void cargarModulos(TreeNode nodo)
    {
        nodo.ChildNodes.Clear();

        DataSet temp = new DataSet();

        temp = ctrlFunctionalRequirement.obtenerModulos(Int32.Parse(nodo.Value));

        foreach (DataRow row in temp.Tables[0].Rows)
        {
            TreeNode newNode = new TreeNode(row["Nombre"].ToString(), row["Id"].ToString());
            newNode.PopulateOnDemand = true;
            newNode.Collapse();
            newNode.SelectAction = TreeNodeSelectAction.Select;
            nodo.ChildNodes.Add(newNode);
        }
        TreeNode n = new TreeNode("Requerimientos No Funcionales");

        n.Collapse();
        n.SelectAction = TreeNodeSelectAction.Select;
        nodo.ChildNodes.Add(n);
        n.Expand();
        n.Collapse();
    }


    //carga los requerimientos en el arbol
    private void cargarRequerimientos(TreeNode nodo)
    {
        nodo.ChildNodes.Clear();

        DataSet temp = new DataSet();

        temp = ctrlFunctionalRequirement.obtenerRequerimientos(Int32.Parse(nodo.Value));

        foreach (DataRow row in temp.Tables[0].Rows)
        {
            TreeNode newNode = new TreeNode(row["Nombre"].ToString(), row["Id"].ToString());
            newNode.PopulateOnDemand = true;
            newNode.Collapse();
            newNode.SelectAction = TreeNodeSelectAction.Select;
            nodo.ChildNodes.Add(newNode);
        }
    }

    //carga los subrequerimientos en el arbol
    private void cargarSubRequerimientos(TreeNode nodo)
    {
        nodo.ChildNodes.Clear();

        DataSet temp = new DataSet();

        temp = ctrlFunctionalRequirement.obtenerSubrequerimientos(Int32.Parse(nodo.Value));

        foreach (DataRow row in temp.Tables[0].Rows)
        {
            TreeNode newNode = new TreeNode(row["Nombre"].ToString(), row["Id"].ToString());
            newNode.PopulateOnDemand = true;
            newNode.Collapse();
            newNode.SelectAction = TreeNodeSelectAction.Select;
            nodo.ChildNodes.Add(newNode);
        }
    }

    //carga los requerimientos no funcionales en el arbol
    private void cargarRequerimientosNoFuncionales(TreeNode nodo)
    {
        nodo.ChildNodes.Clear();

        DataSet temp = new DataSet();

        temp = ctrlFunctionalRequirement.obtenerRequerimientosNoFuncionales(Int32.Parse(nodo.Parent.Value));

        foreach (DataRow row in temp.Tables[0].Rows)
        {
            TreeNode newNode = new TreeNode(row["Nombre"].ToString(), row["Id"].ToString());
            newNode.PopulateOnDemand = true;
            newNode.Collapse();
            newNode.SelectAction = TreeNodeSelectAction.Select;
            nodo.ChildNodes.Add(newNode);
        }
    }

    // Evento que se dispara cuando se expande un nodo
    protected void tree_TreeNodeExpanded(object sender, TreeNodeEventArgs e)
    {
        switch (e.Node.Depth)
        {
            case 0:
                cargarProyectos(e.Node);
                break;

            case 1:
                cargarModulos(e.Node);
                break;

            case 2:
                if (e.Node.Text == "Requerimientos No Funcionales")
                {
                    cargarRequerimientosNoFuncionales(e.Node);
                }
                else
                {
                    cargarRequerimientos(e.Node);
                }
                break;

            case 3:
                if (e.Node.Parent.Text != "Requerimientos No Funcionales")
                {
                    cargarSubRequerimientos(e.Node);
                }
                break;
        }
    }

	    // Llena los grids de historial en la pantalla
    private void fillGridRF(int id) {
        CtrlRequerimientos manager = new CtrlRequerimientos();
        DataSet data = manager.getHistorialRF(id);
        historialRF.DataSource = data;
        historialRF.DataBind();
        upPanRF.Update();
    }

    // Llena los grids de historial en la pantalla
    private void fillGridRNF(int id)
    {
        CtrlRequerimientos manager = new CtrlRequerimientos();
        DataSet data = manager.getHistorialRNF(id);
        historialRNF.DataSource = data;
        historialRNF.DataBind();
        updatePanelRNF2.Update();
    }
	
    /// <summary>
    ///  Evento que se dispara cuando se selecciona un nodo del arbol
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void tree_SelectedNodeChanged(object sender, EventArgs e)
    {
        hideNV("RF");
        hideNV("RNF");
        btnAgregarMod.Enabled = false;
        btnBorrarMod.Enabled = false;
        txtNombreModulo.Enabled = false;
        if (tree.SelectedNode.Text == "Requerimientos No Funcionales")
        {
            consultando.Visible = false;
            modificando.Visible = false;
            ninguno.Visible = true;
            insertando.Visible = false;
            consultandoProyecto.Visible = false;

            clearFields();
            position = "RNF";
            switchPanel(position); //< Parece ineficiente, pero position se usa para definir cosas en ejecutar operacion.
            DesactivarBotonesRNF();      // al pararse sobre requerimientos no funcionales solo puedo agregar requerimientos no funcionales
            btnAddRNF.Enabled = true;
        }
        else
        {
            //Es requerimiento o funcional o no funcional.
            if (tree.SelectedNode.Depth >= 3)
            {
                if (tree.SelectedNode.Parent.Text == "Requerimientos No Funcionales") // consulto un requerimiento no funcional
                {
                    consultando.Visible = true;
                    modificando.Visible = false;
                    ninguno.Visible = false;
                    insertando.Visible = false;
                    consultandoProyecto.Visible = false;

                    clearFields();
                    position = "RNF";
                    switchPanel(position); //< Parece ineficiente, pero position se usa para definir cosas en ejecutar operacion.
                    loadFields(ctrlFunctionalRequirement.consultaRequerimientoNoFuncional(Int32.Parse(tree.SelectedNode.Value)));
					fillGridRNF(Convert.ToInt32(tree.SelectedNode.Value));
                    btnModRNF.Enabled = true; // puedo modificarlo, borrarlo pero no insertar otro ahi
                    btnDelRNF.Enabled = true;
                    btnAddRNF.Enabled = false;
                }
                else                  // consulto un requerimiento funcional
                {
                    consultando.Visible = true;
                    modificando.Visible = false;
                    ninguno.Visible = false;
                    insertando.Visible = false;
                    consultandoProyecto.Visible = false;

                    clearFields();
                    position = "RF";
                    switchPanel(position); //< Parece ineficiente, pero position se usa para definir cosas en ejecutar operacion.
                    loadFields(ctrlFunctionalRequirement.consultaRequerimientoFuncional(Int32.Parse(tree.SelectedNode.Value)));
                    fillGridRF(Convert.ToInt32(tree.SelectedNode.Value));
                    btnModRF.Enabled = true; // puedo modificarlo, borrarlo pero no insertar otro ahi
                    btnDelRF.Enabled = true;
                    btnAddRNF.Enabled = false;
                    /////////////////////////////////////////////////////////////////////////////////
                    /////////////////////////////////////////////////////////////////////////////////
                    /////////////////////////////////////////////////////////////////////////////////
                    cargaConflictos();
                    /////////////////////////////////////////////////////////////////////////////////
                    /////////////////////////////////////////////////////////////////////////////////
                    /////////////////////////////////////////////////////////////////////////////////
                    if (tree.SelectedNode.Depth != 4)
                    {
                        btnAddRF.Enabled = true;
                    }
                    else
                    {
                        btnAddRF.Enabled = false;
                    }
                }
            }

            //Es proyecto
            if (tree.SelectedNode.Depth == 1)
            {
                consultando.Visible = false;
                modificando.Visible = false;
                ninguno.Visible = false;
                insertando.Visible = false;
                consultandoProyecto.Visible = true;

                btnAgregarMod.Enabled = true;
                txtNombreModulo.Enabled = true;
                DesactivarBotonesRNF();
                DesactivarBotonesRF();
                clearFields();
            }

            //Es modulo
            if ((tree.SelectedNode.Depth == 2) && (tree.SelectedNode.Text != "Requerimientos No Funcionales"))
            {
                consultando.Visible = false;
                modificando.Visible = false;
                ninguno.Visible = true;
                insertando.Visible = false;
                consultandoProyecto.Visible = false;

                clearFields();
                position = "RF";
                switchPanel(position); //< Parece ineficiente, pero position se usa para definir cosas en ejecutar operacion.
                btnBorrarMod.Enabled = true;
                DesactivarBotonesRNF();    // en este punto no puede tocar los botones ime
                DesactivarBotonesRF();
                btnAddRF.Enabled = true;
                clearFields();
            }
        }
    }

    // Agrega un modulo
    protected void agregarModulo(object sender, EventArgs e)
    {
        if (txtNombreModulo.Text != "")
        {

            ctrlFunctionalRequirement.agregarModulo(Int32.Parse(tree.SelectedNode.Value), txtNombreModulo.Text);
            tree.SelectedNode.Parent.Collapse();
            tree.SelectedNode.Parent.Expand();
        }
        else {

            ctlMessageRF.showMessage("error", "Debe de insertar un Nombre");

        }
        clearFields();
    }

    // Borra un modulo
    protected void borrarModulo(object sender, EventArgs e)
    {
        ctrlFunctionalRequirement.eliminarModulo(Int32.Parse(tree.SelectedNode.Value));
        tree.SelectedNode.Parent.Collapse();
    }

    // Cambia la interfaz entre RNF y RF
    protected void cambiarCosa(object sender, EventArgs e) 
    {
        if (updatePanelRF.Visible == true)
        {
            updatePanelRF.Visible = false;
            updatePanelRNF.Visible = true;
        }
        else
        {
            updatePanelRF.Visible = true;
            updatePanelRNF.Visible = false;
        }

        PanelPrincipal.Update();
     }

    // Cambia la interfaz entre RNF y RF
    protected void switchPanel(String type)
    {
        if (type == "RNF")
        {
            updatePanelRF.Visible = false;
            updatePanelRNF.Visible = true;
        }
        else
        {
            updatePanelRF.Visible = true;
            updatePanelRNF.Visible = false;
        }

        PanelPrincipal.Update();
    }

    /// <summary>
    /// Agrega un requerimiento funcional
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnAgregarRF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = false;
        insertando.Visible = true;
        consultandoProyecto.Visible = false;

        clearFields();
        changing = "insertar";
        enableFields();
        checkNuevaVersionRF.Enabled = false;
        ctlMessageRF.showMessage("info", "Puede digitar la informacion del requerimiento.");

        btnAddRF.Enabled = false;
        btnModRF.Enabled = false;
        btnDelRF.Enabled = false;

        btnAceptarRF.Enabled = true;
        btnCancelarRF.Enabled = true;
    }

    //Modifica un Requerimiento funcional
    protected void btnModificarRF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = true;
        ninguno.Visible = false;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;

        //clearFields();
        changing = "modificar";
        enableFields();
        checkNuevaVersionRF.Enabled = true;
        ctlMessageRF.showMessage("info", "Puede modificar la informacion del requerimiento.");

        btnAddRF.Enabled = false;
        btnModRF.Enabled = false;
        btnDelRF.Enabled = false;

        btnAceptarRF.Enabled = true;
        btnCancelarRF.Enabled = true;
    }

    //Elimina un Requerimiento funcional
    protected void btnEliminRF(object sender, EventArgs e)
    {
        disableFields();
        btnAceptarRF.Enabled = true;
        btnAceptarRNF.Enabled = true;
        changing = "eliminar";
    }


    //Carga los campos del requerimiento funcional
    private void loadFields(RequerimientoFuncional fR) 
    {

        txtNombre.Text = fR.NombreRequerimiento;
        txtIteracion.Text = fR.Iteracion.ToString();
        txtDescripcion.Text = fR.Descripcion;
        txtJustificacion.Text = fR.Justificacion;
        ctlComboBoxFuente.setSelectedId(fR.Fuente.ToString());
        ctlComboBoxPrioridad.setSelectedId(fR.Prioridad.ToString());
        txtBegin.Text = fR.FechaInicio.Date.ToString();
        txtEnd.Text = fR.FechaFinal.Date.ToString();
        txtEsfuerzo.Text = fR.Esfuerzo;
        ctlComboBoxEstado.setSelectedId(fR.Estado.ToString());
        txtCriterioDeAceptacion.Text = fR.CriterioAceptacion;
        upPanRF.Update();
    }


    //Carga los campos del requerimiento no funcional
    private void loadFields(RequerimientoNoFuncional rNF)
    {
        txtNombreRNF.Text = rNF.NombreRequerimiento;
        txtDescripcionRNF.Text = rNF.Descripcion;
    }

    // Esconde validaciones
    private void hideValidations()
    {
        nombreValidation.Visible = false;
        nombreValFormat.Visible = false;
        nombreValComment.Visible = false;
        iteracionValidation.Visible = false;
        iteracionValFormat.Visible = false;
        iteracionValComment.Visible = false;
        descripcionValidation.Visible = false;
        descripcionValComment.Visible = false;
        justificacionValidation.Visible = false;
        justificacionValComment.Visible = false;
        beginValidation.Visible = false;
        beginValFormat.Visible = false;
        beginValComment.Visible = false;
        endValidation.Visible = false;
        endValFormat.Visible = false;
        endValComment.Visible = false;
        endValComment2.Visible = false;
        esfuerzoValidation.Visible = false;
        esfuerzoValFormat.Visible = false;
        criterioValidation.Visible = false;
        criterioValComment.Visible = false;
        nombreRNFValidation.Visible = false;
        nombreRNFValFormat.Visible = false;
        nombreRNFValComment.Visible = false;
        descripcionRNFValidation.Visible = false;
        descripcionRNFValComment.Visible = false;
        fechaRNFValidation.Visible = false;
        fechaRNFValFormat.Visible = false;
        fechaRNFValComment.Visible = false;
        descripcionCambioValidation.Visible = false;
        descripcionCambioValComment.Visible = false;
        fechaVersionValComment.Visible = false;
        fechaVersionValFormat.Visible = false;
        fechaVersionValidation.Visible = false;
        descripcionVersionValComment.Visible = false;
        descripcionVersionValidation.Visible = false;
        fechaRNFValidation.Visible = false;
        fechaRNFValFormat.Visible = false;
        fechaRNFValComment.Visible = false;
    }

    //Habilita la vista de la parte de nueva version en requerimiento funcional
    protected void checkNVRF(object sender, EventArgs e) 
    {
        if (checkNuevaVersionRF.Checked)
        {
            updateNuevaVersionRF.Visible = true;
        }
        else
        {
            updateNuevaVersionRF.Visible = false;
        }
    }

    //Habilita la vista de la parte de nueva version en requerimiento no funcional
    protected void checkNVRNF(object sender, EventArgs e)
    {
        if (checkNuevaVersionRNF.Checked)
        {
            updateNuevaVersionRNF.Visible = true;
        }
        else
        {
            updateNuevaVersionRNF.Visible = false;
        }
    
    }


    //Limpia los campos
    public void clearFields()
    {
        hideValidations();
        txtNombre.Text = "";
        txtIteracion.Text = "";
        txtDescripcion.Text = "";
        txtJustificacion.Text = "";
        txtBegin.Text = "";
        txtEnd.Text = "";
        txtEsfuerzo.Text = "";
        txtCriterioDeAceptacion.Text = "";
        txtFechaVersion.Text = "";
        txtDescripcionVersion.Text = "";

        txtNombreRNF.Text = "";
        txtDescripcionRNF.Text = "";
        txtFechaRNF.Text = "";
        txtDescripcionCambioRNF.Text = "";
        txtNombreModulo.Text = "";
    }

    // Habilita los campos para la insercion/modificacion
    public void enableFields()
    {
        txtNombre.Enabled = true;
        txtIteracion.Enabled = true;
        txtDescripcion.Enabled = true;
        txtJustificacion.Enabled = true;
        ctlComboBoxFuente.Enabled = true;
        ctlComboBoxPrioridad.Enabled = true;
        txtBegin.Enabled = true;
        txtEnd.Enabled = true;
        txtEsfuerzo.Enabled = true;
        ctlComboBoxEstado.Enabled = true;
        txtCriterioDeAceptacion.Enabled = true;
        checkNuevaVersionRF.Enabled = true;
        txtFechaVersion.Enabled = true;
        ctlComboBoxFuente.Enabled = true;
        txtDescripcionVersion.Enabled = true;

        txtNombreRNF.Enabled = true;
        txtDescripcionRNF.Enabled = true;
        txtFechaRNF.Enabled = true;
        ctlComboBoxFuenteRNF.Enabled = true;
        txtDescripcionCambioRNF.Enabled = true;
        btnAceptarRF.Enabled = true;
        btnAceptarRNF.Enabled = true;
    }

    // Deshabilita los campos
    public void disableFields()
    {
        txtNombre.Enabled = false;
        txtIteracion.Enabled = false;
        txtDescripcion.Enabled = false;
        txtJustificacion.Enabled = false;
        ctlComboBoxFuente.Enabled = false;
        ctlComboBoxPrioridad.Enabled = false;
        txtBegin.Enabled = false;
        txtEnd.Enabled = false;
        txtEsfuerzo.Enabled = false;
        ctlComboBoxEstado.Enabled = false;
        txtCriterioDeAceptacion.Enabled = false;
        checkNuevaVersionRF.Enabled = false;
        txtFechaVersion.Enabled = false;
        ctlComboBoxFuente.Enabled = false;
        txtDescripcionVersion.Enabled = false;

        txtNombreRNF.Enabled = false;
        txtDescripcionRNF.Enabled = false;
        txtFechaRNF.Enabled = false;
        ctlComboBoxFuenteRNF.Enabled = false;
        txtDescripcionCambioRNF.Enabled = false;
        btnAceptarRF.Enabled = false;
        btnAceptarRNF.Enabled = false;
        btnBorrarMod.Enabled = false;
        btnAgregarMod.Enabled = false;
        txtNombreModulo.Enabled = false;

    }

    public void DesactivarBotonesRF()
    {
        btnModRF.Enabled = false;
        btnAddRF.Enabled = false;
        btnDelRF.Enabled = false;
        btnAceptarRF.Enabled = false;
        btnCancelarRF.Enabled = false;
    }

    public void DesactivarBotonesRNF()
    {
        btnModRNF.Enabled = false;
        btnAddRNF.Enabled = false;
        btnDelRNF.Enabled = false;
        btnAceptarRNF.Enabled = false;
        btnCancelarRNF.Enabled = false;

    }

    /// <summary>
    /// Boton Aceptar
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>

    protected void btnAceptRF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = true;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;
        if(changing == "eliminar"){
                    if (tree.SelectedNode.Depth > 2)
                    {
                        clearFields();
                        disableFields();
                       
                        ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), "", 0, "", "", 0, DateTime.Now,
                            DateTime.Now, "", 0, 0, "", DateTime.Now, -1, "", "eliminar", -1, -1);
                        tree.SelectedNode.Parent.Collapse();
                        tree.SelectedNode.Parent.Expand();
                        PanelArbol.Update();
                        ctlMessageRF.showMessage("info", "Requerimiento Eliminado.");
                        DesactivarBotonesRF();
                        clearFields();
                    }
                    else
                    {
                        ctlMessageRF.showMessage("error", "Debe seleccionar un Requerimiento.");
                    }
                }else{
        if (validateFields())
        {
            if (checkNuevaVersionRF.Checked)
            {
                if (validateNV())
                {

                    if (tree.SelectedNode.Depth == 3)
                    {
                        //public int ejecutarOperacion(int id, String nombreRequerimiento, int iteracion, String descripcion,
                        //String justificacion, int fuente,DateTime fechaInicio, DateTime fechaFinal, int esfuerzo,int estado,
                        //int prioridad , String criterioAceptacion, DateTime fechaCambio, int fuenteCambio, String descripcionCambio,
                        //String tipoOperacion, int depenR, int depenM)
                        ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombre.Text,
                            Int32.Parse(txtIteracion.Text), txtDescripcion.Text, txtJustificacion.Text, Int32.Parse(ctlComboBoxFuente.getSelectedId()),
                            DateTime.Parse(txtBegin.Text, format), DateTime.Parse(txtEnd.Text, format), txtEsfuerzo.Text,
                            Int32.Parse(ctlComboBoxEstado.getSelectedId()), Int32.Parse(ctlComboBoxPrioridad.getSelectedId()),
                            txtCriterioDeAceptacion.Text, Convert.ToDateTime(txtFechaVersion.Text), Convert.ToInt32(ctlComboBoxVersion.getSelectedId()),
                            txtDescripcionVersion.Text, "nuevaVersion", -1, Int32.Parse(tree.SelectedNode.Parent.Value));
                        tree.SelectedNode.Parent.Collapse();
                        tree.SelectedNode.Parent.Expand();
                        PanelArbol.Update();
                        disableFields();
                        ctlMessageRF.showMessage("info", "Requerimiento Modificado.");
                        DesactivarBotonesRF();
                        //clearFields();
                        hideNV("RF");
                    }
                    else
                    {
                        if (tree.SelectedNode.Depth == 4)
                        {
                            ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombre.Text,
                                Int32.Parse(txtIteracion.Text), txtDescripcion.Text, txtJustificacion.Text, Int32.Parse(ctlComboBoxFuente.getSelectedId()),
                                DateTime.Parse(txtBegin.Text, format), DateTime.Parse(txtEnd.Text, format), txtEsfuerzo.Text,
                                Int32.Parse(ctlComboBoxEstado.getSelectedId()), Int32.Parse(ctlComboBoxPrioridad.getSelectedId()),
                                txtCriterioDeAceptacion.Text, Convert.ToDateTime(txtFechaVersion.Text), Convert.ToInt32(ctlComboBoxVersion.getSelectedId()),
                                txtDescripcionVersion.Text, "nuevaVersion", Int32.Parse(tree.SelectedNode.Parent.Value), -1);
                            tree.SelectedNode.Parent.Collapse();
                            tree.SelectedNode.Parent.Expand();
                            PanelArbol.Update();
                            disableFields();
                            ctlMessageRF.showMessage("info", "Requerimiento Modificado.");
                            DesactivarBotonesRF();
                            //clearFields();
                            hideNV("RF");
                        }
                        else
                        {
                            ctlMessageRF.showMessage("error", "Debe seleccionar un Requerimiento.");
                        }
                    }
                }
            }
            else
            {
                if (changing == "insertar")
                {
                    if (tree.SelectedNode.Depth == 2)
                    {
                        //public int ejecutarOperacion(int id, String nombreRequerimiento, int iteracion, String descripcion,
                        //String justificacion, int fuente,DateTime fechaInicio, DateTime fechaFinal, int esfuerzo,int estado,
                        //int prioridad , String criterioAceptacion, DateTime fechaCambio, int fuenteCambio, String descripcionCambio,
                        //String tipoOperacion, int depenR, int depenM)
                        ctrlFunctionalRequirement.ejecutarOperacion(0, txtNombre.Text, Int32.Parse(txtIteracion.Text), txtDescripcion.Text,
                            txtJustificacion.Text, Int32.Parse(ctlComboBoxFuente.getSelectedId()), DateTime.Parse(txtBegin.Text, format),
                            DateTime.Parse(txtEnd.Text, format), txtEsfuerzo.Text, Int32.Parse(ctlComboBoxEstado.getSelectedId()),
                            Int32.Parse(ctlComboBoxPrioridad.getSelectedId()), txtCriterioDeAceptacion.Text, DateTime.Now, -1, "", "insertar",
                            -1, Int32.Parse(tree.SelectedNode.Value));
                        tree.SelectedNode.Collapse();
                        tree.SelectedNode.Expand();
                        PanelArbol.Update();
                        disableFields();
                        ctlMessageRF.showMessage("info", "Requerimiento Insertado.");
                        DesactivarBotonesRF();
                        //clearFields();

                    }
                    else
                    {
                        if (tree.SelectedNode.Depth == 3)
                        {
                            //public int ejecutarOperacion(int id, String nombreRequerimiento, int iteracion, String descripcion,
                            //String justificacion, int fuente,DateTime fechaInicio, DateTime fechaFinal, int esfuerzo,int estado,
                            //int prioridad , String criterioAceptacion, DateTime fechaCambio, int fuenteCambio, String descripcionCambio,
                            //String tipoOperacion, int depenR, int depenM)
                            ctrlFunctionalRequirement.ejecutarOperacion(0, txtNombre.Text, Int32.Parse(txtIteracion.Text), txtDescripcion.Text,
                                txtJustificacion.Text, Int32.Parse(ctlComboBoxFuente.getSelectedId()), DateTime.Parse(txtBegin.Text, format),
                                DateTime.Parse(txtEnd.Text, format), txtEsfuerzo.Text, Int32.Parse(ctlComboBoxEstado.getSelectedId()),
                                Int32.Parse(ctlComboBoxPrioridad.getSelectedId()), txtCriterioDeAceptacion.Text, DateTime.Now, -1, "", "insertar",
                                Int32.Parse(tree.SelectedNode.Value), -1);
                            tree.SelectedNode.Collapse();
                            tree.SelectedNode.Expand();
                            PanelArbol.Update();
                            disableFields();
                            ctlMessageRF.showMessage("info", "Requerimiento Insertado.");
                            DesactivarBotonesRF();
                            //clearFields();
                        }
                        else
                        {
                            ctlMessageRF.showMessage("error", "Debe seleccionar un Modulo o un Requerimiento.");
                        }
                    }
                }

                else if (changing == "modificar")
                {
                    if (tree.SelectedNode.Depth == 3)
                    {
                        //public int ejecutarOperacion(int id, String nombreRequerimiento, int iteracion, String descripcion, String justificacion,
                        //int fuente,DateTime fechaInicio, DateTime fechaFinal, int esfuerzo,int estado, int prioridad , String criterioAceptacion,
                        //DateTime fechaCambio, int fuenteCambio, String descripcionCambio, String tipoOperacion, int depenR, int depenM)
                        ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombre.Text, Int32.Parse(txtIteracion.Text),
                            txtDescripcion.Text, txtJustificacion.Text, Int32.Parse(ctlComboBoxFuente.getSelectedId()),
                            DateTime.Parse(txtBegin.Text, format), DateTime.Parse(txtEnd.Text, format), txtEsfuerzo.Text,
                            Int32.Parse(ctlComboBoxEstado.getSelectedId()), Int32.Parse(ctlComboBoxPrioridad.getSelectedId()),
                            txtCriterioDeAceptacion.Text, DateTime.Now, -1, "", "modificar", -1, Int32.Parse(tree.SelectedNode.Parent.Value));
                        tree.SelectedNode.Parent.Collapse();
                        tree.SelectedNode.Parent.Expand();
                        PanelArbol.Update();
                        disableFields();
                        ctlMessageRF.showMessage("info", "Requerimiento Modificado.");
                        DesactivarBotonesRF();
                        //clearFields();
                    }
                    else
                    {
                        if (tree.SelectedNode.Depth == 4)
                        {
                            ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombre.Text,
                                Int32.Parse(txtIteracion.Text), txtDescripcion.Text, txtJustificacion.Text, Int32.Parse(ctlComboBoxFuente.getSelectedId()),
                                DateTime.Parse(txtBegin.Text, format), DateTime.Parse(txtEnd.Text, format), txtEsfuerzo.Text,
                                Int32.Parse(ctlComboBoxEstado.getSelectedId()), Int32.Parse(ctlComboBoxPrioridad.getSelectedId()),
                                txtCriterioDeAceptacion.Text, DateTime.Now, -1, "", "modificar", Int32.Parse(tree.SelectedNode.Parent.Value), -1);
                            tree.SelectedNode.Parent.Collapse();
                            tree.SelectedNode.Parent.Expand();
                            PanelArbol.Update();
                            disableFields();
                            ctlMessageRF.showMessage("info", "Requerimiento Modificado.");
                            DesactivarBotonesRF();
                            //clearFields();
                        }
                        else
                        {
                            ctlMessageRF.showMessage("error", "Debe seleccionar un Requerimiento.");
                        }
                    }
                }
                
            }
        }
    }
        enableButtons();

        tree.Nodes[0].Selected = true;
    }
    
    /// <summary>
    /// Boton Cancelar
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnCancRF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = true;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;

        changing = "";
        clearFields();
        hideNV("RF");
        disableFields();

        enableButtons();
    }


    protected void btnAgregarRNF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = false;
        insertando.Visible = true;
        consultandoProyecto.Visible = false;

        clearFields();
        changing = "insertar";
        enableFields();
        checkNuevaVersionRNF.Enabled = false;
        ctlMessageRF.showMessage("info", "Puede digitar la informacion del requerimiento no funcional.");

        btnAddRNF.Enabled = false;
        btnModRNF.Enabled = false;
        btnDelRNF.Enabled = false;

		btnAceptarRNF.Enabled = true;
        btnCancelarRNF.Enabled = true;
    }

    protected void btnModificarRNF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = true;
        ninguno.Visible = false;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;

        changing = "modificar";
        enableFields();

        btnAddRNF.Enabled = false;
        btnModRNF.Enabled = false;
        btnDelRNF.Enabled = false;

        btnAceptarRNF.Enabled = true;
        btnCancelarRNF.Enabled = true;

        checkNuevaVersionRNF.Enabled = true;
        ctlMessageRF.showMessage("info", "Puede modificar la informacion del requerimiento no funcional.");
    }

    protected void btnEliminarRNF(object sender, EventArgs e)
    {
        disableFields();
       // btnAceptarRF.Enabled = true;
        btnAceptarRNF.Enabled = true;
        btnCancelarRNF.Enabled = true;
        changing = "eliminar";
    }

    protected void btnAceptRNF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = true;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;

        if (checkNuevaVersionRNF.Checked) {
            if (validateNV())
            {
                //public int ejecutarOperacion(int id, String nombreRequerimiento, String descripcion, DataTable modulos,DateTime fechaCambio, int idFuenteCambio, String descripcionCambio, String tipoOperacion, int idProyeto)
                ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombreRNF.Text, txtDescripcionRNF.Text,
                    null, Convert.ToDateTime(txtFechaRNF.Text), Convert.ToInt32(ctlComboBoxFuenteRNF.getSelectedId()),
                    txtDescripcionCambioRNF.Text, "nuevaVersion", Int32.Parse(tree.SelectedNode.Parent.Parent.Value));
                tree.SelectedNode.Parent.Collapse();
                tree.SelectedNode.Parent.Expand();
                PanelArbol.Update();
                disableFields();
                ctlMessageRF.showMessage("info", "Requerimiento Modificado.");
                DesactivarBotonesRF();
                //clearFields();
                hideNV("RNF");
            }
        }else{
            if (tree.SelectedNode.Depth == 2 && tree.SelectedNode.Text == "Requerimientos No Funcionales")
            {
                if (changing == "insertar")
                {
                    ctrlFunctionalRequirement.ejecutarOperacion(0, txtNombreRNF.Text, txtDescripcionRNF.Text, null, DateTime.Now, -1,
                        "", "insertar", Int32.Parse(tree.SelectedNode.Parent.Value.ToString()));
                    //cargarRequerimientosNoFuncionales(tree.SelectedNode);
                    tree.SelectedNode.Collapse();
                    tree.SelectedNode.Expand();
                    PanelArbol.Update();
                    disableFields();
                    ctlMessageRF.showMessage("info", "Requerimiento Insertado.");
                    changing = "";
                    DesactivarBotonesRNF();
                    //clearFields();
                }
            }
            else
            {

                if (changing == "modificar")
                {

                    ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombreRNF.Text,
                        txtDescripcionRNF.Text, null, DateTime.Today, 0, " ", "modificar", Int32.Parse(tree.SelectedNode.Parent.Parent.Value));
                    tree.SelectedNode.Parent.Collapse();
                    tree.SelectedNode.Parent.Expand();
                    PanelArbol.Update();
                    disableFields();
                    ctlMessageRF.showMessage("info", "Requerimiento Modificado.");
                    changing = "";
                    DesactivarBotonesRNF();
                }
                else
                {
                    if (changing == "eliminar")
                    {
                        disableFields();
                        ctrlFunctionalRequirement.ejecutarOperacion(Int32.Parse(tree.SelectedNode.Value), txtNombreRNF.Text, txtDescripcionRNF.Text, null, DateTime.Today, -1, "", "eliminar", Int32.Parse(tree.SelectedNode.Parent.Parent.Value));
                        tree.SelectedNode.Parent.Collapse();
                        tree.SelectedNode.Parent.Expand();
                        PanelArbol.Update();
                        clearFields();
                        ctlMessageRF.showMessage("info", "Requerimiento No funcional Eliminado.");
                        changing = "";
                        DesactivarBotonesRNF();
                        clearFields();
                    }
                    else
                    {
                        ctlMessageRF.showMessage("error", "Debe seleccionar un Requerimiento.");
                    }

                }
            }
         }

        enableButtons();

        tree.Nodes[0].Selected = true;
    }    
   

    protected void btnCancRNF(object sender, EventArgs e)
    {
        consultando.Visible = false;
        modificando.Visible = false;
        ninguno.Visible = true;
        insertando.Visible = false;
        consultandoProyecto.Visible = false;

        changing = "";
        clearFields();
        disableFields();

        enableButtons();
    }

    // Esconde el control de versiones.
    private void hideNV(String type) {
        switch (type) { 
            case "RF":
                updateNuevaVersionRF.Visible = false;
                checkNuevaVersionRF.Checked = false;
                checkNuevaVersionRF.Enabled = false;
                break;
            case "RNF":
                updateNuevaVersionRNF.Visible = false;
                checkNuevaVersionRNF.Checked = false;
                checkNuevaVersionRNF.Enabled = false;
                break;
        }
        
    }


    // Valida los campos de nueva version
    private bool validateNV() {

        bool valid = true;
        
        if (validateFields())
        {
            Regex regularNotNull = new Regex("^(.{1,50})$");
            DateTime temp = new DateTime();
            System.IFormatProvider format = new System.Globalization.CultureInfo("es-ES", true);

            if (updateNuevaVersionRF.Visible == true)
            {
                if (checkNuevaVersionRNF.Checked)
                {
                    if (txtFechaRNF.Text != "")
                    {
                        if (!(DateTime.TryParse(txtFechaRNF.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                        {
                            fechaVersionValidation.Visible = true;
                            fechaVersionValFormat.Visible = true;
                            valid = false;
                        }
                    }
                    else
                    {
                        fechaVersionValidation.Visible = true;
                        fechaVersionValComment.Visible = true;
                        valid = false;
                    }
                }
                else {
                    if (txtFechaVersion.Text != "")
                    {
                        if (!(DateTime.TryParse(txtFechaVersion.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                        {
                            fechaVersionValidation.Visible = true;
                            fechaVersionValFormat.Visible = true;
                            valid = false;
                        }
                    }
                    else
                    {
                        fechaVersionValidation.Visible = true;
                        fechaVersionValComment.Visible = true;
                        valid = false;
                    }
                }

                if (txtDescripcion.Text == "")
                {
                    descripcionVersionValidation.Visible = true;
                    descripcionVersionValComment.Visible = true;
                    valid = false;
                }
            }
            else if (updateNuevaVersionRNF.Visible == true)
            {
                if (txtFechaRNF.Text != "")
                {
                    if (!(DateTime.TryParse(txtFechaRNF.Text, format, System.Globalization.DateTimeStyles.None, out temp)))
                    {
                        fechaRNFValidation.Visible = true;
                        fechaRNFValFormat.Visible = true;
                        valid = false;
                    }
                }
                else
                {
                    fechaRNFValidation.Visible = true;
                    fechaRNFValComment.Visible = true;
                    valid = false;
                }

                if (txtDescripcionRNF.Text == "")
                {
                    descripcionCambioValidation.Visible = true;
                    descripcionCambioValComment.Visible = true;
                    valid = false;
                }
            }

        }
        else
        {
            valid = false;
        }

        return valid;
    }

    //Procedimiento para saber cuales botones habilitar luego de darle aceptar o cancelar.
    private void enableButtons()
    {
        if (tree.SelectedNode != null)
        {
            if (tree.SelectedNode.Text == "Requerimientos No Funcionales")
            {
                btnAddRNF.Enabled = true;
                btnModRNF.Enabled = false;
                btnDelRNF.Enabled = false;

                btnAddRF.Enabled = false;
                btnModRF.Enabled = false;
                btnDelRF.Enabled = false;
            }
            else
            {
                //Es requerimiento o funcional o no funcional.
                if (tree.SelectedNode.Depth >= 3)
                {
                    //Requerimiento no funcional
                    if (tree.SelectedNode.Parent.Text == "Requerimientos No Funcionales")
                    {
                        btnAddRNF.Enabled = false;
                        btnModRNF.Enabled = true;
                        btnDelRNF.Enabled = true;

                        btnAddRF.Enabled = false;
                        btnModRF.Enabled = false;
                        btnDelRF.Enabled = false;
                    }
                    else
                    {
                        //requerimiento func
                        if (tree.SelectedNode.Depth == 3)
                        {
                            btnAddRNF.Enabled = false;
                            btnModRNF.Enabled = false;
                            btnDelRNF.Enabled = false;

                            btnAddRF.Enabled = true;
                            btnModRF.Enabled = true;
                            btnDelRF.Enabled = true;
                        }
                        //subrequerimiento func
                        else
                        {
                            btnAddRNF.Enabled = false;
                            btnModRNF.Enabled = false;
                            btnDelRNF.Enabled = false;

                            btnAddRF.Enabled = false;
                            btnModRF.Enabled = true;
                            btnDelRF.Enabled = true;
                        }
                    }
                }

                if (tree.SelectedNode.Depth == 0)
                {
                    btnAddRNF.Enabled = false;
                    btnModRNF.Enabled = false;
                    btnDelRNF.Enabled = false;

                    btnAddRF.Enabled = false;
                    btnModRF.Enabled = false;
                    btnDelRF.Enabled = false;
                }

                //Es proyecto
                if (tree.SelectedNode.Depth == 1)
                {
                    btnAddRNF.Enabled = false;
                    btnModRNF.Enabled = false;
                    btnDelRNF.Enabled = false;

                    btnAddRF.Enabled = false;
                    btnModRF.Enabled = false;
                    btnDelRF.Enabled = false;
                }

                //Es modulo
                if ((tree.SelectedNode.Depth == 2) && (tree.SelectedNode.Text != "Requerimientos No Funcionales"))
                {
                    btnAddRNF.Enabled = true;
                    btnModRNF.Enabled = false;
                    btnDelRNF.Enabled = false;

                    btnAddRF.Enabled = true;
                    btnModRF.Enabled = false;
                    btnDelRF.Enabled = false;
                }
            }
        }
        else
        {
            tree.Nodes[0].Selected = true;
        }
    }

    protected void historialView(object sender, int iValue)
    {

    }
    
}